#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>

namespace custom
{
    // 模板类，用于实现动态数组功能
    template <typename T>
    class Vector
    {
    public:
        // 构造函数
        Vector();
        // 拷贝构造函数
        Vector(const Vector<T> &vec);
        // 析构函数
        ~Vector();

        // 返回当前数组的大小
        int size() const;

        // 在数组末尾添加元素
        void push_back(const T &value);
        // 删除数组末尾的元素
        void pop_back();

        // 清空数组，释放资源
        void clear();

        // 判断数组是否为空
        bool empty() const;

        // 重载下标操作符，返回可修改的元素
        T& operator[](int index);
        // 重载下标操作符，返回不可修改的元素
        const T& operator[](int index) const;

    private:
        // 存储元素的指针
        T *data_ = nullptr;
        // 当前数组的大小
        int size_ = 0;
        // 数组的容量
        int capacity_ = 0;
    };

    template <typename T>
    Vector<T>::Vector()
    {
        data_ = nullptr;
        size_ = 0;
        capacity_ = 0;
    }

    template <typename T>
    Vector<T>::Vector(const Vector<T> &vec)
    {
        data_ = new T[vec.size_];
        this->size_ = vec.size_;
        this->capacity_ = vec.capacity_;
        for (int i = 0; i < size_; i++)
        {
            data_[i] = vec.data_[i];
        }
    }

    template <typename T>
    Vector<T>::~Vector()
    {
        if(data_!= nullptr)
        {
            delete[] data_;
            data_ = nullptr;
        }
    }

    template <typename T>
    int Vector<T>::size() const
    {
        return size_;
    }

    template <typename T>
    void Vector<T>::push_back(const T &value)
    {
        if (size_ == capacity_)
        {
            // 数组已满，需要扩容
            if (capacity_ == 0)
            {
                capacity_ = 10;
            }
            else
            {
                capacity_ *= 2;
            }
            T *new_data = new T[capacity_];
            for (int i = 0; i < size_; i++)
            {
                new_data[i] = data_[i];
            }
            delete[] data_;
            data_ = new_data;
        }
        else if(size_ < capacity_)
        {
            // 数组未满，直接添加元素
        }
        else
        {
            // 发生了错误
            std::cout << "Error: vector overflow." << std::endl;
            while(1);
        }
        data_[size_] = value;
        size_++;
    }

    template <typename T>
    void Vector<T>::pop_back()
    {
        if (size_ > 0)
        {
            size_--;
        }
        else
        {
            // 数组为空，不能删除元素
#ifdef DEBUG
            std::cout << "Error: vector underflow." << std::endl;
            while(1);
#endif
        }
    }

    template <typename T>
    void Vector<T>::clear()
    {
        delete[] data_;
        data_ = nullptr;
        size_ = 0;
        capacity_ = 0;
    }

    template <typename T>
    bool Vector<T>::empty() const
    {
        return (size_ == 0);
    }

    template <typename T>
    T& Vector<T>::operator[](int index)
    {
        if(index < 0 || index >= size_)
        {
            // 越界访问，抛出异常
#ifdef DEBUG
            std::cout << "Error: vector index out of range." << std::endl;
            while(1);
#endif
        }
        return data_[index];
    }

    template <typename T>
    const T& Vector<T>::operator[](int index) const
    {
        return data_[index];
    }
}

#endif // VECTOR_H